home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume25 / trash / part05 < prev    next >
Encoding:
Text File  |  1992-03-23  |  31.1 KB  |  1,993 lines

  1. Newsgroups: comp.sources.unix
  2. From: bruce@beta.cs.su.oz.au (Bruce Janson)
  3. Subject: v25i159: trash - simulate process execution in MIPS RISC/os 4.52, Part05/08
  4. Sender: unix-sources-moderator@pa.dec.com
  5. Approved: vixie@pa.dec.com
  6.  
  7. Submitted-By: bruce@beta.cs.su.oz.au (Bruce Janson)
  8. Posting-Number: Volume 25, Issue 159
  9. Archive-Name: trash/part05
  10.  
  11. #! /bin/sh
  12. # This is a shell archive.  Remove anything before this line, then unpack
  13. # it by saving it into a file and typing "sh file".  To overwrite existing
  14. # files, type "sh file -c".  You can also feed this as standard input via
  15. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  16. # will see the following message at the end:
  17. #        "End of archive 5 (of 8)."
  18. # Contents:  generic.c
  19. # Wrapped by bruce@basser on Tue Mar  3 23:25:23 1992
  20. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  21. if test -f 'generic.c' -a "${1}" != "-c" ; then 
  22.   echo shar: Will not clobber existing file \"'generic.c'\"
  23. else
  24. echo shar: Extracting \"'generic.c'\" \(28291 characters\)
  25. sed "s/^X//" >'generic.c' <<'END_OF_FILE'
  26. X#include        "register.h"
  27. X#include        "symtab.h"
  28. X#include        "diblock.h"
  29. X#include        "instrn.h"
  30. X#include        "process.h"
  31. X#include        "res.h"
  32. X
  33. Xextern int        bufset();
  34. Xextern int        fd_close();
  35. Xextern int        fd_invalid();
  36. Xextern int        fd_lookup();
  37. Xextern int        fd_open();
  38. Xextern int        mgets();
  39. Xextern int        dmget();
  40. Xextern int        mget();
  41. Xextern int        dmput();
  42. Xextern int        mput();
  43. X
  44. Xextern int        errno;
  45. X
  46. Xextern unsigned long    arg[];
  47. X
  48. Xextern int        return_errno;    /* errno goes here. */
  49. Xextern long        return_value0;    /* Result 1 value goes here. */
  50. Xextern long        return_value1;    /* Result 2 value goes here. */
  51. X
  52. Xextern char        *sys_call_buf;    /* Scratch buf. */
  53. X
  54. Xint
  55. Xgeneric_accept(syscallno)
  56. Xint    syscallno;
  57. X{
  58. X    int    addrlen;
  59. X    void    *addrlenp;
  60. X    void    *addrp;
  61. X
  62. X    addrlen = 0;
  63. X
  64. X    if (mget(arg[2], &addrlen, sizeof(addrlen), &addrlenp) == -1)
  65. X        return -1;
  66. X
  67. X    if (dmget(arg[1], addrlen, &addrp) == -1)
  68. X        return -1;
  69. X
  70. X    Rstart;
  71. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), addrp, addrlenp);
  72. X    return_errno = errno;
  73. X    Rstop;
  74. X
  75. X    if (return_value0 != -1)
  76. X        return_value0 = fd_open(return_value0);
  77. X
  78. X    if (dmput(arg[1], addrp, addrlen, return_value0) == -1)
  79. X        return -1;
  80. X
  81. X    if (mput(arg[2], addrlenp, sizeof(addrlen), return_value0) == -1)
  82. X        return -1;
  83. X
  84. X    return 0;
  85. X}
  86. X
  87. Xint
  88. Xgeneric_access(syscallno)
  89. Xint    syscallno;
  90. X{
  91. X    char    *cp;
  92. X
  93. X    if (mgets(arg[0], &cp) == -1)
  94. X        return -1;
  95. X
  96. X    Rstart;
  97. X    return_value0 = syscall(syscallno, cp, (int)arg[1]);
  98. X    return_errno = errno;
  99. X    Rstop;
  100. X
  101. X    return 0;
  102. X}
  103. X
  104. Xint
  105. Xgeneric_acct(syscallno)
  106. Xint    syscallno;
  107. X{
  108. X    char    *cp;
  109. X
  110. X    if (mgets(arg[0], &cp) == -1)
  111. X        return -1;
  112. X
  113. X    Rstart;
  114. X    return_value0 = syscall(syscallno, cp);
  115. X    return_errno = errno;
  116. X    Rstop;
  117. X
  118. X    return 0;
  119. X}
  120. X
  121. Xint
  122. Xgeneric_adjtime(syscallno, tv, tvz, otv, otvz)
  123. Xint    syscallno;
  124. Xvoid    *tv;
  125. Xint    tvz;
  126. Xvoid    *otv;
  127. Xint    otvz;
  128. X{
  129. X    void    *tvp;
  130. X    void    *otvp;
  131. X
  132. X    if (mget(arg[0], tv, tvz, &tvp) == -1)
  133. X        return -1;
  134. X
  135. X    if (mget(arg[1], otv, otvz, &otvp) == -1)
  136. X        return -1;
  137. X
  138. X    Rstart;
  139. X    return_value0 = syscall(syscallno, tvp, otvp);
  140. X    return_errno = errno;
  141. X    Rstop;
  142. X
  143. X    if (mput(arg[1], otvp, otvz, return_value0) == -1)
  144. X        return -1;
  145. X
  146. X    if (mput(arg[0], tvp, tvz, return_value0) == -1)
  147. X        return -1;
  148. X
  149. X    return 0;
  150. X}
  151. X
  152. Xint
  153. Xgeneric_alarm(syscallno)
  154. Xint    syscallno;
  155. X{
  156. X    Rstart;
  157. X    return_value0 = syscall(syscallno, (int)arg[0]);
  158. X    return_errno = errno;
  159. X    Rstop;
  160. X
  161. X    return 0;
  162. X}
  163. X
  164. Xint
  165. Xgeneric_async_daemon(syscallno)
  166. Xint    syscallno;
  167. X{
  168. X    Rstart;
  169. X    return_value0 = syscall(syscallno);
  170. X    return_errno = errno;
  171. X    Rstop;
  172. X
  173. X    return 0;
  174. X}
  175. X
  176. Xint
  177. Xgeneric_bind(syscallno)
  178. Xint    syscallno;
  179. X{
  180. X    int    namelen;
  181. X    void    *namep;
  182. X
  183. X    namelen = arg[2];
  184. X
  185. X    if (dmget(arg[1], namelen, &namep) == -1)
  186. X        return -1;
  187. X
  188. X    Rstart;
  189. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), namep, namelen);
  190. X    return_errno = errno;
  191. X    Rstop;
  192. X
  193. X    if (dmput(arg[1], namep, namelen, return_value0) == -1)
  194. X        return -1;
  195. X
  196. X    return 0;
  197. X}
  198. X
  199. Xint
  200. Xgeneric_brk(syscallno)
  201. Xint    syscallno;
  202. X{
  203. X    if (quiet_procbreakget(&return_value1) == -1)
  204. X        return -1;
  205. X
  206. X    if (quiet_procbreakput(arg[0]) == -1)
  207. X        return -1;
  208. X
  209. X    return_value0 = 0;
  210. X    return_errno = 0;
  211. X
  212. X    return 0;
  213. X}
  214. X
  215. Xint
  216. Xgeneric_cachectl(syscallno)
  217. Xint    syscallno;
  218. X{
  219. X    /*
  220. X     * TODO: check args to cachectl.
  221. X     *
  222. X    Rstart;
  223. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  224. X    return_errno = errno;
  225. X    Rstop;
  226. X     */
  227. X
  228. X    return 0;
  229. X}
  230. X
  231. Xint
  232. Xgeneric_cacheflush(syscallno)
  233. Xint    syscallno;
  234. X{
  235. X    /*
  236. X     * TODO: check args to cacheflush.
  237. X     *
  238. X    Rstart;
  239. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  240. X    return_errno = errno;
  241. X    Rstop;
  242. X     */
  243. X
  244. X    return 0;
  245. X}
  246. X
  247. Xint
  248. Xgeneric_chdir(syscallno)
  249. Xint    syscallno;
  250. X{
  251. X    char    *cp;
  252. X
  253. X    if (mgets(arg[0], &cp) == -1)
  254. X        return -1;
  255. X
  256. X    Rstart;
  257. X    return_value0 = syscall(syscallno, cp);
  258. X    return_errno = errno;
  259. X    Rstop;
  260. X
  261. X    return 0;
  262. X}
  263. X
  264. Xint
  265. Xgeneric_chmod(syscallno)
  266. Xint    syscallno;
  267. X{
  268. X    char    *cp;
  269. X
  270. X    if (mgets(arg[0], &cp) == -1)
  271. X        return -1;
  272. X
  273. X    Rstart;
  274. X    return_value0 = syscall(syscallno, cp, (int)arg[1]);
  275. X    return_errno = errno;
  276. X    Rstop;
  277. X
  278. X    return 0;
  279. X}
  280. X
  281. Xint
  282. Xgeneric_chown(syscallno)
  283. Xint    syscallno;
  284. X{
  285. X    char    *cp;
  286. X
  287. X    if (mgets(arg[0], &cp) == -1)
  288. X        return -1;
  289. X
  290. X    Rstart;
  291. X    return_value0 = syscall(syscallno, cp, (int)arg[1], (int)arg[2]);
  292. X    return_errno = errno;
  293. X    Rstop;
  294. X
  295. X    return 0;
  296. X}
  297. X
  298. Xint
  299. Xgeneric_chroot(syscallno)
  300. Xint    syscallno;
  301. X{
  302. X    char    *cp;
  303. X
  304. X    if (mgets(arg[0], &cp) == -1)
  305. X        return -1;
  306. X
  307. X    Rstart;
  308. X    return_value0 = syscall(syscallno, cp);
  309. X    return_errno = errno;
  310. X    Rstop;
  311. X
  312. X    return 0;
  313. X}
  314. X
  315. Xint
  316. Xgeneric_close(syscallno)
  317. Xint    syscallno;
  318. X{
  319. X    Rstart;
  320. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]));
  321. X    return_errno = errno;
  322. X    Rstop;
  323. X
  324. X    return fd_close((int)arg[0]);
  325. X}
  326. X
  327. Xint
  328. Xgeneric_connect(syscallno)
  329. Xint    syscallno;
  330. X{
  331. X    int    namelen;
  332. X    void    *namep;
  333. X
  334. X    namelen = arg[2];
  335. X
  336. X    if (dmget(arg[1], namelen, &namep) == -1)
  337. X        return -1;
  338. X
  339. X    Rstart;
  340. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), namep, namelen);
  341. X    return_errno = errno;
  342. X    Rstop;
  343. X
  344. X    if (dmput(arg[1], namep, namelen, return_value0) == -1)
  345. X        return -1;
  346. X
  347. X    return 0;
  348. X}
  349. X
  350. Xint
  351. Xgeneric_creat(syscallno)
  352. Xint    syscallno;
  353. X{
  354. X    char    *cp;
  355. X
  356. X    if (mgets(arg[0], &cp) == -1)
  357. X        return -1;
  358. X
  359. X    Rstart;
  360. X    return_value0 = syscall(syscallno, cp, (int)arg[1]);
  361. X    return_errno = errno;
  362. X    Rstop;
  363. X
  364. X    if (return_value0 != -1)
  365. X    {
  366. X        if ((return_value0 = fd_open(return_value0)) == -1)
  367. X            return -1;
  368. X    }
  369. X
  370. X    return 0;
  371. X}
  372. X
  373. Xint
  374. Xgeneric_dup(syscallno)
  375. Xint    syscallno;
  376. X{
  377. X    Rstart;
  378. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]));
  379. X    return_errno = errno;
  380. X    Rstop;
  381. X
  382. X    if (return_value0 != -1)
  383. X    {
  384. X        if ((return_value0 = fd_open(return_value0)) == -1)
  385. X            return -1;
  386. X    }
  387. X
  388. X    return 0;
  389. X}
  390. X
  391. Xint
  392. Xgeneric_exit(syscallno)
  393. Xint    syscallno;
  394. X{
  395. X    histo_dump();
  396. X    hist_dump();
  397. X
  398. X    (void)procclose();
  399. X
  400. X#if    defined(PIXIE)
  401. X    exit((int)arg[0]);
  402. X#else    /* defined(PIXIE) */
  403. X    syscall(syscallno, (int)arg[0]);
  404. X#endif    /* defined(PIXIE) */
  405. X}
  406. X
  407. Xint
  408. Xgeneric_fchmod(syscallno)
  409. Xint    syscallno;
  410. X{
  411. X    Rstart;
  412. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  413. X    return_errno = errno;
  414. X    Rstop;
  415. X
  416. X    return 0;
  417. X}
  418. X
  419. Xint
  420. Xgeneric_fchown(syscallno)
  421. Xint    syscallno;
  422. X{
  423. X    Rstart;
  424. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1], (int)arg[2]);
  425. X    return_errno = errno;
  426. X    Rstop;
  427. X
  428. X    return 0;
  429. X}
  430. X
  431. Xint
  432. Xgeneric_flock(syscallno)
  433. Xint    syscallno;
  434. X{
  435. X    Rstart;
  436. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1]);
  437. X    return_errno = errno;
  438. X    Rstop;
  439. X
  440. X    return 0;
  441. X}
  442. X
  443. Xint
  444. Xgeneric_fork(syscallno)
  445. Xint    syscallno;
  446. X{
  447. X    int    parent_pid;
  448. X
  449. X    parent_pid = getpid();
  450. X
  451. X    errno = 0;
  452. X
  453. X    Rstart;
  454. X    return_value0 = syscall(syscallno);
  455. X    return_errno = errno;
  456. X    Rstop;
  457. X
  458. X    if ((P.p_pid = getpid()) != parent_pid)
  459. X        return_value0 = 0;
  460. X
  461. X    switch (return_value0)
  462. X    {
  463. X    case -1:    /* error */
  464. X        break;
  465. X
  466. X    case 0:        /* child */
  467. X        return_value1 = 1;
  468. X        break;
  469. X
  470. X    default:    /* parent */
  471. X        return_value1 = 0;
  472. X        break;
  473. X    }
  474. X
  475. X    return 0;
  476. X}
  477. X
  478. Xint
  479. Xgeneric_fstat(syscallno, sbufz)
  480. Xint    syscallno;
  481. Xint    sbufz;
  482. X{
  483. X    void    *sbufp;
  484. X
  485. X    if (dmget(arg[1], sbufz, &sbufp) == -1)
  486. X        return -1;
  487. X
  488. X    Rstart;
  489. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), sbufp);
  490. X    return_errno = errno;
  491. X    Rstop;
  492. X
  493. X    if (dmput(arg[1], sbufp, sbufz, return_value0) == -1)
  494. X        return -1;
  495. X
  496. X    return 0;
  497. X}
  498. X
  499. Xint
  500. Xgeneric_fsync(syscallno)
  501. Xint    syscallno;
  502. X{
  503. X    Rstart;
  504. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]));
  505. X    return_errno = errno;
  506. X    Rstop;
  507. X
  508. X    return 0;
  509. X}
  510. X
  511. Xint
  512. Xgeneric_ftruncate(syscallno)
  513. Xint    syscallno;
  514. X{
  515. X    Rstart;
  516. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), arg[1]);
  517. X    return_errno = errno;
  518. X    Rstop;
  519. X
  520. X    return 0;
  521. X}
  522. X
  523. Xint
  524. Xgeneric_getdents(syscallno)
  525. Xint    syscallno;
  526. X{
  527. X    int    nbyte;
  528. X    char    *buf;
  529. X
  530. X    nbyte = arg[2];
  531. X
  532. X    if (dmget(arg[1], nbyte, &buf) == -1)
  533. X        return -1;
  534. X
  535. X    Rstart;
  536. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), buf, nbyte);
  537. X    return_errno = errno;
  538. X    Rstop;
  539. X
  540. X    if (dmput(arg[1], buf, nbyte, return_value0) == -1)
  541. X        return -1;
  542. X
  543. X    return 0;
  544. X}
  545. X
  546. Xint
  547. Xgeneric_getdirentries(syscallno)
  548. Xint    syscallno;
  549. X{
  550. X    int    nbytes;
  551. X    char    *bufp;
  552. X    long    base;
  553. X    long    *basep;
  554. X
  555. X    nbytes = arg[2];
  556. X
  557. X    if (dmget(arg[1], nbytes, &bufp) == -1)
  558. X        return -1;
  559. X
  560. X    if (mget(arg[3], &base, sizeof(base), &basep) == -1)
  561. X        return -1;
  562. X
  563. X    Rstart;
  564. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), bufp, nbytes, basep);
  565. X    return_errno = errno;
  566. X    Rstop;
  567. X
  568. X    if (mput(arg[3], basep, sizeof(base), return_value0) == -1)
  569. X        return -1;
  570. X
  571. X    if (dmput(arg[1], bufp, return_value0, return_value0) == -1)
  572. X        return -1;
  573. X
  574. X    return 0;
  575. X}
  576. X
  577. Xint
  578. Xgeneric_getdomainname(syscallno)
  579. Xint    syscallno;
  580. X{
  581. X    int    namelen;
  582. X    char    *name;
  583. X
  584. X    namelen = arg[1];
  585. X
  586. X    if (dmget(arg[0], namelen, &name) == -1)
  587. X        return -1;
  588. X
  589. X    Rstart;
  590. X    return_value0 = syscall(syscallno, name, namelen);
  591. X    return_errno = errno;
  592. X    Rstop;
  593. X
  594. X    if (dmput(arg[0], name, namelen, return_value0) == -1)
  595. X        return -1;
  596. X
  597. X    return 0;
  598. X}
  599. X
  600. Xint
  601. Xgeneric_getdtablesize(syscallno)
  602. Xint    syscallno;
  603. X{
  604. X    Rstart;
  605. X    return_value0 = syscall(syscallno);
  606. X    return_errno = errno;
  607. X    Rstop;
  608. X
  609. X    return 0;
  610. X}
  611. X
  612. Xint
  613. Xgeneric_getgroups(syscallno, maxngroups)
  614. Xint    syscallno;
  615. Xint    maxngroups;
  616. X{
  617. X    int    gidsetlen;
  618. X    int    *gidsetp;
  619. X
  620. X    gidsetlen = (int)arg[0];
  621. X
  622. X    if (gidsetlen < 0)
  623. X        gidsetlen = 0;
  624. X    else if (gidsetlen > maxngroups)
  625. X        gidsetlen = maxngroups;
  626. X
  627. X    if (dmget(arg[1], gidsetlen * sizeof(int), &gidsetp) == -1)
  628. X        return -1;
  629. X
  630. X    Rstart;
  631. X    return_value0 = syscall(syscallno, gidsetlen, gidsetp);
  632. X    return_errno = errno;
  633. X    Rstop;
  634. X
  635. X    if (dmput(arg[1], gidsetp, return_value0 * sizeof(int), return_value0) == -1)
  636. X        return -1;
  637. X
  638. X    return 0;
  639. X}
  640. X
  641. Xint
  642. Xgeneric_gethostid(syscallno)
  643. Xint    syscallno;
  644. X{
  645. X    Rstart;
  646. X    return_value0 = syscall(syscallno);
  647. X    return_errno = errno;
  648. X    Rstop;
  649. X
  650. X    return 0;
  651. X}
  652. X
  653. Xint
  654. Xgeneric_gethostname(syscallno)
  655. Xint    syscallno;
  656. X{
  657. X    int    namelen;
  658. X    char    *name;
  659. X
  660. X    namelen = arg[1];
  661. X
  662. X    if (dmget(arg[0], namelen, &name) == -1)
  663. X        return -1;
  664. X
  665. X    Rstart;
  666. X    return_value0 = syscall(syscallno, name, namelen);
  667. X    return_errno = errno;
  668. X    Rstop;
  669. X
  670. X    if (dmput(arg[0], name, namelen, return_value0) == -1)
  671. X        return -1;
  672. X
  673. X    return 0;
  674. X}
  675. X
  676. Xint
  677. Xgeneric_getitimer(syscallno, itimervalz)
  678. Xint    syscallno;
  679. Xint    itimervalz;
  680. X{
  681. X    void    *itimervalp;
  682. X
  683. X    if (dmget(arg[1], itimervalz, &itimervalp) == -1)
  684. X        return -1;
  685. X
  686. X    Rstart;
  687. X    return_value0 = syscall(syscallno, (int)arg[0], itimervalp);
  688. X    return_errno = errno;
  689. X    Rstop;
  690. X
  691. X    if (dmput(arg[1], itimervalp, itimervalz, return_value0) == -1)
  692. X        return -1;
  693. X
  694. X    return 0;
  695. X}
  696. X
  697. Xint
  698. Xgeneric_getpagesize(syscallno)
  699. Xint    syscallno;
  700. X{
  701. X    Rstart;
  702. X    return_value0 = syscall(syscallno);
  703. X    return_errno = errno;
  704. X    Rstop;
  705. X
  706. X    return 0;
  707. X}
  708. X
  709. Xint
  710. Xgeneric_getpeername(syscallno)
  711. Xint    syscallno;
  712. X{
  713. X    int    namelen;
  714. X    void    *namelenp;
  715. X    void    *namep;
  716. X
  717. X    namelen = 0;
  718. X
  719. X    if (mget(arg[2], &namelen, sizeof(namelen), &namelenp) == -1)
  720. X        return -1;
  721. X
  722. X    if (dmget(arg[1], namelen, &namep) == -1)
  723. X        return -1;
  724. X
  725. X    Rstart;
  726. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), namep, namelenp);
  727. X    return_errno = errno;
  728. X    Rstop;
  729. X
  730. X    if (dmput(arg[1], namep, namelen, return_value0) == -1)
  731. X        return -1;
  732. X
  733. X    if (mput(arg[2], namelenp, sizeof(namelen), return_value0) == -1)
  734. X        return -1;
  735. X
  736. X    return 0;
  737. X}
  738. X
  739. Xint
  740. Xgeneric_getpid(syscallno)
  741. Xint    syscallno;
  742. X{
  743. X    Rstart;
  744. X    return_value0 = syscall(syscallno);
  745. X    return_errno = errno;
  746. X    Rstop;
  747. X
  748. X    return 0;
  749. X}
  750. X
  751. Xint
  752. Xgeneric_getpriority(syscallno)
  753. Xint    syscallno;
  754. X{
  755. X    Rstart;
  756. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  757. X    return_errno = errno;
  758. X    Rstop;
  759. X
  760. X    return 0;
  761. X}
  762. X
  763. Xint
  764. Xgeneric_getrlimit(syscallno, rlimitz)
  765. Xint    syscallno;
  766. Xint    rlimitz;
  767. X{
  768. X    void    *rlimitp;
  769. X
  770. X    if (dmget(arg[1], rlimitz, &rlimitp) == -1)
  771. X        return -1;
  772. X
  773. X    Rstart;
  774. X    return_value0 = syscall(syscallno, arg[0], rlimitp);
  775. X    return_errno = errno;
  776. X    Rstop;
  777. X
  778. X    if (dmput(arg[1], rlimitp, rlimitz, return_value0) == -1)
  779. X        return -1;
  780. X
  781. X    return 0;
  782. X}
  783. X
  784. Xint
  785. Xgeneric_getrusage(syscallno, rusagez)
  786. Xint    syscallno;
  787. Xint    rusagez;
  788. X{
  789. X    void    *rusagep;
  790. X
  791. X    if (dmget(arg[1], rusagez, &rusagep) == -1)
  792. X        return -1;
  793. X
  794. X    Rstart;
  795. X    return_value0 = syscall(syscallno, arg[0], rusagep);
  796. X    return_errno = errno;
  797. X    Rstop;
  798. X
  799. X    if (dmput(arg[1], rusagep, rusagez, return_value0) == -1)
  800. X        return -1;
  801. X
  802. X    return 0;
  803. X}
  804. X
  805. Xint
  806. Xgeneric_gettimeofday(syscallno, tv, tvz, tz, tzz)
  807. Xint    syscallno;
  808. Xvoid    *tv;
  809. Xint    tvz;
  810. Xvoid    *tz;
  811. Xint    tzz;
  812. X{
  813. X    void    *tvp;
  814. X    void    *tzp;
  815. X
  816. X    if (mget(arg[0], tv, tvz, &tvp) == -1)
  817. X        return -1;
  818. X
  819. X    if (mget(arg[1], tz, tzz, &tzp) == -1)
  820. X        return -1;
  821. X
  822. X    Rstart;
  823. X    return_value0 = syscall(syscallno, tvp, tzp);
  824. X    return_errno = errno;
  825. X    Rstop;
  826. X
  827. X    if (mput(arg[1], tzp, tzz, return_value0) == -1)
  828. X        return -1;
  829. X
  830. X    if (mput(arg[0], tvp, tvz, return_value0) == -1)
  831. X        return -1;
  832. X
  833. X    return 0;
  834. X}
  835. X
  836. Xint
  837. Xgeneric_getsockname(syscallno)
  838. Xint    syscallno;
  839. X{
  840. X    int    namelen;
  841. X    void    *namelenp;
  842. X    void    *namep;
  843. X
  844. X    namelen = 0;
  845. X
  846. X    if (mget(arg[2], &namelen, sizeof(namelen), &namelenp) == -1)
  847. X        return -1;
  848. X
  849. X    if (dmget(arg[1], namelen, &namep) == -1)
  850. X        return -1;
  851. X
  852. X    Rstart;
  853. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), namep, namelenp);
  854. X    return_errno = errno;
  855. X    Rstop;
  856. X
  857. X    if (dmput(arg[1], namep, namelen, return_value0) == -1)
  858. X        return -1;
  859. X
  860. X    if (mput(arg[2], namelenp, sizeof(namelen), return_value0) == -1)
  861. X        return -1;
  862. X
  863. X    return 0;
  864. X}
  865. X
  866. Xint
  867. Xgeneric_getsockopt(syscallno)
  868. Xint    syscallno;
  869. X{
  870. X    int    optlen;
  871. X    int    *optlenp;
  872. X    char    *optvalp;
  873. X
  874. X    optlen = 0;
  875. X
  876. X    if (mget(arg[4], &optlen, sizeof(optlen), &optlenp) == -1)
  877. X        return -1;
  878. X
  879. X    if (dmget(arg[3], optlen, &optvalp) == -1)
  880. X        return -1;
  881. X
  882. X    Rstart;
  883. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1], (int)arg[2], optvalp, optlenp);
  884. X    return_errno = errno;
  885. X    Rstop;
  886. X
  887. X    if (dmput(arg[3], optvalp, optlen, return_value0) == -1)
  888. X        return -1;
  889. X
  890. X    if (mput(arg[4], optlenp, sizeof(optlen), return_value0) == -1)
  891. X        return -1;
  892. X
  893. X    return 0;
  894. X}
  895. X
  896. Xint
  897. Xgeneric_kill(syscallno)
  898. Xint    syscallno;
  899. X{
  900. X    Rstart;
  901. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  902. X    return_errno = errno;
  903. X    Rstop;
  904. X
  905. X    return 0;
  906. X}
  907. X
  908. Xint
  909. Xgeneric_killpg(syscallno)
  910. Xint    syscallno;
  911. X{
  912. X    Rstart;
  913. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  914. X    return_errno = errno;
  915. X    Rstop;
  916. X
  917. X    return 0;
  918. X}
  919. X
  920. Xint
  921. Xgeneric_link(syscallno)
  922. Xint    syscallno;
  923. X{
  924. X    char    *cp;
  925. X    char    name1[1024];
  926. X    char    *name1p;
  927. X
  928. X    if (mgets(arg[0], &name1p) == -1)
  929. X        return -1;
  930. X
  931. X    if (name1p != (char *)0)
  932. X    {
  933. X        (void)strcpy(&name1[0], name1p);
  934. X        name1p = &name1[0];
  935. X    }
  936. X
  937. X    if (mgets(arg[1], &cp) == -1)
  938. X        return -1;
  939. X
  940. X    Rstart;
  941. X    return_value0 = syscall(syscallno, name1p, cp);
  942. X    return_errno = errno;
  943. X    Rstop;
  944. X
  945. X    return 0;
  946. X}
  947. X
  948. Xint
  949. Xgeneric_listen(syscallno)
  950. Xint    syscallno;
  951. X{
  952. X    Rstart;
  953. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1]);
  954. X    return_errno = errno;
  955. X    Rstop;
  956. X
  957. X    return 0;
  958. X}
  959. X
  960. Xint
  961. Xgeneric_lseek(syscallno)
  962. Xint    syscallno;
  963. X{
  964. X    Rstart;
  965. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), arg[1], (int)arg[2]);
  966. X    return_errno = errno;
  967. X    Rstop;
  968. X
  969. X    return 0;
  970. X}
  971. X
  972. Xint
  973. Xgeneric_lstat(syscallno, statb, statbz)
  974. Xint    syscallno;
  975. Xvoid    *statb;
  976. Xint    statbz;
  977. X{
  978. X    char    *cp;
  979. X    void    *statbp;
  980. X
  981. X    if (mgets(arg[0], &cp) == -1)
  982. X        return -1;
  983. X
  984. X    if (mget(arg[1], statb, statbz, &statbp) == -1)
  985. X        return -1;
  986. X
  987. X    Rstart;
  988. X    return_value0 = syscall(syscallno, cp, statbp);
  989. X    return_errno = errno;
  990. X    Rstop;
  991. X
  992. X    if (mput(arg[1], statbp, statbz, return_value0) == -1)
  993. X        return -1;
  994. X
  995. X    return 0;
  996. X}
  997. X
  998. Xint
  999. Xgeneric_mkdir(syscallno)
  1000. Xint    syscallno;
  1001. X{
  1002. X    char    *cp;
  1003. X
  1004. X    if (mgets(arg[0], &cp) == -1)
  1005. X        return -1;
  1006. X
  1007. X    Rstart;
  1008. X    return_value0 = syscall(syscallno, cp, (int)arg[1]);
  1009. X    return_errno = errno;
  1010. X    Rstop;
  1011. X
  1012. X    return 0;
  1013. X}
  1014. X
  1015. Xint
  1016. Xgeneric_mknod(syscallno)
  1017. Xint    syscallno;
  1018. X{
  1019. X    char    *cp;
  1020. X
  1021. X    if (mgets(arg[0], &cp) == -1)
  1022. X        return -1;
  1023. X
  1024. X    Rstart;
  1025. X    return_value0 = syscall(syscallno, cp, (int)arg[1], (int)arg[2]);
  1026. X    return_errno = errno;
  1027. X    Rstop;
  1028. X
  1029. X    return 0;
  1030. X}
  1031. X
  1032. Xint
  1033. Xgeneric_nfssvc(syscallno)
  1034. Xint    syscallno;
  1035. X{
  1036. X    Rstart;
  1037. X    return_value0 = syscall(syscallno, arg[0]);
  1038. X    return_errno = errno;
  1039. X    Rstop;
  1040. X
  1041. X    return 0;
  1042. X}
  1043. X
  1044. Xint
  1045. Xgeneric_nice(syscallno)
  1046. Xint    syscallno;
  1047. X{
  1048. X    Rstart;
  1049. X    return_value0 = syscall(syscallno, (int)arg[0]);
  1050. X    return_errno = errno;
  1051. X    Rstop;
  1052. X
  1053. X    return 0;
  1054. X}
  1055. X
  1056. Xint
  1057. Xgeneric_open(syscallno)
  1058. Xint    syscallno;
  1059. X{
  1060. X    char    *cp;
  1061. X
  1062. X    if (mgets(arg[0], &cp) == -1)
  1063. X        return -1;
  1064. X
  1065. X    Rstart;
  1066. X    return_value0 = syscall(syscallno, cp, (int)arg[1], (int)arg[2]);
  1067. X    return_errno = errno;
  1068. X    Rstop;
  1069. X
  1070. X    if (return_value0 != -1)
  1071. X        return_value0 = fd_open(return_value0);
  1072. X
  1073. X    return 0;
  1074. X}
  1075. X
  1076. Xint
  1077. Xgeneric_pause(syscallno)
  1078. Xint    syscallno;
  1079. X{
  1080. X    Rstart;
  1081. X    return_value0 = syscall(syscallno);
  1082. X    return_errno = errno;
  1083. X    Rstop;
  1084. X
  1085. X    return 0;
  1086. X}
  1087. X
  1088. Xint
  1089. Xgeneric_plock(syscallno)
  1090. Xint    syscallno;
  1091. X{
  1092. X    Rstart;
  1093. X    return_value0 = syscall(syscallno, (int)arg[0]);
  1094. X    return_errno = errno;
  1095. X    Rstop;
  1096. X
  1097. X    return 0;
  1098. X}
  1099. X
  1100. Xint
  1101. Xgeneric_profil(syscallno)
  1102. Xint    syscallno;
  1103. X{
  1104. X    /*
  1105. X     * TODO -- pseudo-profiling
  1106. X     */
  1107. X    return_value0 = 0;
  1108. X    return_errno = 0;
  1109. X
  1110. X    return 0;
  1111. X}
  1112. X
  1113. Xint
  1114. Xgeneric_ptrace(syscallno)
  1115. Xint    syscallno;
  1116. X{
  1117. X    Rstart;
  1118. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2], (int)arg[3]);
  1119. X    return_errno = errno;
  1120. X    Rstop;
  1121. X
  1122. X    return 0;
  1123. X}
  1124. X
  1125. Xint
  1126. Xgeneric_read(syscallno)
  1127. Xint    syscallno;
  1128. X{
  1129. X    int    nbyte;
  1130. X    char    *buf;
  1131. X
  1132. X    /*
  1133. X     * It seems that some programs rely on this
  1134. X     * error being detected before some others
  1135. X     * (specifically, an illegal buffer address).
  1136. X     */
  1137. X    if (fd_invalid((int)arg[0]))
  1138. X    {
  1139. X        return_value0 = -1;
  1140. X        return_errno = errno;
  1141. X
  1142. X        return 0;
  1143. X    }
  1144. X
  1145. X    nbyte = arg[2];
  1146. X
  1147. X    if (dmget(arg[1], nbyte, &buf) == -1)
  1148. X        return -1;
  1149. X
  1150. X    Rstart;
  1151. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), buf, nbyte);
  1152. X    return_errno = errno;
  1153. X    Rstop;
  1154. X
  1155. X    if (dmput(arg[1], buf, return_value0, return_value0) == -1)
  1156. X        return -1;
  1157. X
  1158. X    return 0;
  1159. X}
  1160. X
  1161. Xint
  1162. Xgeneric_readlink(syscallno)
  1163. Xint    syscallno;
  1164. X{
  1165. X    char    *pathp;
  1166. X    char    path[1024];
  1167. X    char    *buf;
  1168. X    int    bufsiz;
  1169. X
  1170. X    if (mgets(arg[0], &pathp) == -1)
  1171. X        return -1;
  1172. X
  1173. X    if (pathp != (char *)0)
  1174. X    {
  1175. X        (void)strcpy(&path[0], pathp);
  1176. X        pathp = &path[0];
  1177. X    }
  1178. X
  1179. X    bufsiz = arg[2];
  1180. X
  1181. X    if (bufset(bufsiz) == -1)
  1182. X        return -1;
  1183. X
  1184. X    if (mget(arg[1], sys_call_buf, bufsiz, &buf) == -1)
  1185. X        return -1;
  1186. X
  1187. X    Rstart;
  1188. X    return_value0 = syscall(syscallno, pathp, buf, bufsiz);
  1189. X    return_errno = errno;
  1190. X    Rstop;
  1191. X
  1192. X    if (mput(arg[1], buf, return_value0, return_value0) == -1)
  1193. X        return -1;
  1194. X
  1195. X    return 0;
  1196. X}
  1197. X
  1198. Xint
  1199. Xgeneric_recv(syscallno)
  1200. Xint    syscallno;
  1201. X{
  1202. X    int    len;
  1203. X    char    *buf;
  1204. X
  1205. X    len = arg[2];
  1206. X
  1207. X    if (dmget(arg[1], len, &buf) == -1)
  1208. X        return -1;
  1209. X
  1210. X    Rstart;
  1211. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), buf, len, (int)arg[3]);
  1212. X    return_errno = errno;
  1213. X    Rstop;
  1214. X
  1215. X    if (dmput(arg[1], buf, return_value0, return_value0) == -1)
  1216. X        return -1;
  1217. X
  1218. X    return 0;
  1219. X}
  1220. X
  1221. Xint
  1222. Xgeneric_recvfrom(syscallno, from)
  1223. Xint    syscallno;
  1224. Xvoid    *from;
  1225. X{
  1226. X    int    len;
  1227. X    char    *buf;
  1228. X    void    *fromp;
  1229. X    int    fromlen;
  1230. X    int    *fromlenp;
  1231. X
  1232. X    len = arg[2];
  1233. X
  1234. X    if (dmget(arg[1], len, &buf) == -1)
  1235. X        return -1;
  1236. X
  1237. X    fromlen = 0;
  1238. X
  1239. X    if (mget(arg[5], &fromlen, sizeof(fromlen), &fromlenp) == -1)
  1240. X        return -1;
  1241. X
  1242. X    if (mget(arg[4], from, fromlen, &fromp) == -1)
  1243. X        return -1;
  1244. X
  1245. X    Rstart;
  1246. X    return_value0 =
  1247. X    syscall
  1248. X    (
  1249. X        syscallno,
  1250. X        fd_lookup((int)arg[0]),
  1251. X        buf,
  1252. X        len,
  1253. X        (int)arg[3],
  1254. X        fromp,
  1255. X        fromlenp
  1256. X    );
  1257. X    return_errno = errno;
  1258. X    Rstop;
  1259. X
  1260. X    if (mput(arg[4], fromp, fromlen, return_value0) == -1)
  1261. X        return -1;
  1262. X
  1263. X    if (mput(arg[5], fromlenp, sizeof(fromlen), return_value0) == -1)
  1264. X        return -1;
  1265. X
  1266. X    if (dmput(arg[1], buf, return_value0, return_value0) == -1)
  1267. X        return -1;
  1268. X
  1269. X    return 0;
  1270. X}
  1271. X
  1272. Xint
  1273. Xgeneric_rename(syscallno)
  1274. Xint    syscallno;
  1275. X{
  1276. X    char    *fromp;
  1277. X    char    fromname[1024];
  1278. X    char    *cp;
  1279. X
  1280. X    if (mgets(arg[0], &fromp) == -1)
  1281. X        return -1;
  1282. X
  1283. X    if (fromp != (char *)0)
  1284. X    {
  1285. X        (void)strcpy(&fromname[0], fromp);
  1286. X        fromp = &fromname[0];
  1287. X    }
  1288. X
  1289. X    if (mgets(arg[1], &cp) == -1)
  1290. X        return -1;
  1291. X
  1292. X    Rstart;
  1293. X    return_value0 = syscall(syscallno, fromp, cp);
  1294. X    return_errno = errno;
  1295. X    Rstop;
  1296. X
  1297. X    return 0;
  1298. X}
  1299. X
  1300. Xint
  1301. Xgeneric_rmdir(syscallno)
  1302. Xint    syscallno;
  1303. X{
  1304. X    char    *cp;
  1305. X
  1306. X    if (mgets(arg[0], &cp) == -1)
  1307. X        return -1;
  1308. X
  1309. X    Rstart;
  1310. X    return_value0 = syscall(syscallno, cp);
  1311. X    return_errno = errno;
  1312. X    Rstop;
  1313. X
  1314. X    return 0;
  1315. X}
  1316. X
  1317. Xint
  1318. Xgeneric_send(syscallno)
  1319. Xint    syscallno;
  1320. X{
  1321. X    int    len;
  1322. X    char    *msg;
  1323. X
  1324. X    len = arg[2];
  1325. X
  1326. X    if (dmget(arg[1], len, &msg) == -1)
  1327. X        return -1;
  1328. X
  1329. X    Rstart;
  1330. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), msg, len, (int)arg[3]);
  1331. X    return_errno = errno;
  1332. X    Rstop;
  1333. X
  1334. X    return 0;
  1335. X}
  1336. X
  1337. Xint
  1338. Xgeneric_sendto(syscallno, to)
  1339. Xint    syscallno;
  1340. Xvoid    *to;
  1341. X{
  1342. X    char    *msg;
  1343. X    int    len;
  1344. X    void    *top;
  1345. X    int    tolen;
  1346. X
  1347. X    len = arg[2];
  1348. X
  1349. X    if (dmget(arg[1], len, &msg) == -1)
  1350. X        return -1;
  1351. X
  1352. X    tolen = arg[5];
  1353. X
  1354. X    if (mget(arg[4], to, tolen, &top) == -1)
  1355. X        return -1;
  1356. X
  1357. X    Rstart;
  1358. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), msg, len, (int)arg[3], top, tolen);
  1359. X    return_errno = errno;
  1360. X    Rstop;
  1361. X
  1362. X    return 0;
  1363. X}
  1364. X
  1365. Xint
  1366. Xgeneric_setdomainname(syscallno)
  1367. Xint    syscallno;
  1368. X{
  1369. X    int    namelen;
  1370. X    char    *name;
  1371. X
  1372. X    namelen = arg[1];
  1373. X
  1374. X    if (dmget(arg[0], namelen, &name) == -1)
  1375. X        return -1;
  1376. X
  1377. X    Rstart;
  1378. X    return_value0 = syscall(syscallno, name, namelen);
  1379. X    return_errno = errno;
  1380. X    Rstop;
  1381. X
  1382. X    if (dmput(arg[0], name, namelen, return_value0) == -1)
  1383. X        return -1;
  1384. X
  1385. X    return 0;
  1386. X}
  1387. X
  1388. Xint
  1389. Xgeneric_setgid(syscallno)
  1390. Xint    syscallno;
  1391. X{
  1392. X    Rstart;
  1393. X    return_value0 = syscall(syscallno, (int)arg[0]);
  1394. X    return_errno = errno;
  1395. X    Rstop;
  1396. X
  1397. X    return 0;
  1398. X}
  1399. X
  1400. Xint
  1401. Xgeneric_setgroups(syscallno)
  1402. Xint    syscallno;
  1403. X{
  1404. X    int    ngroups;
  1405. X    int    *gidset;
  1406. X
  1407. X    ngroups = (int)arg[0];
  1408. X
  1409. X    if (ngroups < 0)
  1410. X        ngroups = 0;
  1411. X
  1412. X    if (dmget(arg[1], ngroups * sizeof(int), &gidset) == -1)
  1413. X        return -1;
  1414. X
  1415. X    Rstart;
  1416. X    return_value0 = syscall(syscallno, ngroups, gidset);
  1417. X    return_errno = errno;
  1418. X    Rstop;
  1419. X
  1420. X    return 0;
  1421. X}
  1422. X
  1423. Xint
  1424. Xgeneric_sethostid(syscallno)
  1425. Xint    syscallno;
  1426. X{
  1427. X    Rstart;
  1428. X    return_value0 = syscall(syscallno, arg[0]);
  1429. X    return_errno = errno;
  1430. X    Rstop;
  1431. X
  1432. X    return 0;
  1433. X}
  1434. X
  1435. Xint
  1436. Xgeneric_setitimer(syscallno, it, itz, oit, oitz)
  1437. Xint    syscallno;
  1438. Xvoid    *it;
  1439. Xint    itz;
  1440. Xvoid    *oit;
  1441. Xint    oitz;
  1442. X{
  1443. X    void    *itp;
  1444. X    void    *oitp;
  1445. X
  1446. X    if (mget(arg[1], it, itz, &itp) == -1)
  1447. X        return -1;
  1448. X
  1449. X    if (mget(arg[2], oit, oitz, &oitp) == -1)
  1450. X        return -1;
  1451. X
  1452. X    Rstart;
  1453. X    return_value0 = syscall(syscallno, (int)arg[0], itp, oitp);
  1454. X    return_errno = errno;
  1455. X    Rstop;
  1456. X
  1457. X    if (mput(arg[2], oitp, oitz, return_value0) == -1)
  1458. X        return -1;
  1459. X
  1460. X    if (mput(arg[1], itp, itz, return_value0) == -1)
  1461. X        return -1;
  1462. X
  1463. X    return 0;
  1464. X}
  1465. X
  1466. Xint
  1467. Xgeneric_setpgid(syscallno)
  1468. Xint    syscallno;
  1469. X{
  1470. X    Rstart;
  1471. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  1472. X    return_errno = errno;
  1473. X    Rstop;
  1474. X
  1475. X    return 0;
  1476. X}
  1477. X
  1478. Xint
  1479. Xgeneric_setpriority(syscallno)
  1480. Xint    syscallno;
  1481. X{
  1482. X    Rstart;
  1483. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  1484. X    return_errno = errno;
  1485. X    Rstop;
  1486. X
  1487. X    return 0;
  1488. X}
  1489. X
  1490. Xint
  1491. Xgeneric_setregid(syscallno)
  1492. Xint    syscallno;
  1493. X{
  1494. X    Rstart;
  1495. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  1496. X    return_errno = errno;
  1497. X    Rstop;
  1498. X
  1499. X    return 0;
  1500. X}
  1501. X
  1502. Xint
  1503. Xgeneric_setreuid(syscallno)
  1504. Xint    syscallno;
  1505. X{
  1506. X    Rstart;
  1507. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  1508. X    return_errno = errno;
  1509. X    Rstop;
  1510. X
  1511. X    return 0;
  1512. X}
  1513. X
  1514. Xint
  1515. Xgeneric_setrlimit(syscallno, rlimitz)
  1516. Xint    syscallno;
  1517. Xint    rlimitz;
  1518. X{
  1519. X    void    *rlimitp;
  1520. X
  1521. X    if (dmget(arg[1], rlimitz, &rlimitp) == -1)
  1522. X        return -1;
  1523. X
  1524. X    Rstart;
  1525. X    return_value0 = syscall(syscallno, arg[0], rlimitp);
  1526. X    return_errno = errno;
  1527. X    Rstop;
  1528. X
  1529. X    if (dmput(arg[1], rlimitp, rlimitz, return_value0) == -1)
  1530. X        return -1;
  1531. X
  1532. X    return 0;
  1533. X}
  1534. X
  1535. Xint
  1536. Xgeneric_setsockopt(syscallno)
  1537. Xint    syscallno;
  1538. X{
  1539. X    int    optlen;
  1540. X    char    *optval;
  1541. X
  1542. X    optlen = arg[4];
  1543. X
  1544. X    if (dmget(arg[3], optlen, &optval) == -1)
  1545. X        return -1;
  1546. X
  1547. X    Rstart;
  1548. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1], (int)arg[2], optval, optlen);
  1549. X    return_errno = errno;
  1550. X    Rstop;
  1551. X
  1552. X    return 0;
  1553. X}
  1554. X
  1555. Xint
  1556. Xgeneric_settimeofday(syscallno, tv, tvz, tz, tzz)
  1557. Xint    syscallno;
  1558. Xvoid    *tv;
  1559. Xint    tvz;
  1560. Xvoid    *tz;
  1561. Xint    tzz;
  1562. X{
  1563. X    void    *tvp;
  1564. X    void    *tzp;
  1565. X
  1566. X    if (mget(arg[0], tv, tvz, &tvp) == -1)
  1567. X        return -1;
  1568. X
  1569. X    if (mget(arg[1], tz, tzz, &tzp) == -1)
  1570. X        return -1;
  1571. X
  1572. X    Rstart;
  1573. X    return_value0 = syscall(syscallno, tvp, tzp);
  1574. X    return_errno = errno;
  1575. X    Rstop;
  1576. X
  1577. X    if (mput(arg[1], tzp, tzz, return_value0) == -1)
  1578. X        return -1;
  1579. X
  1580. X    if (mput(arg[0], tvp, tvz, return_value0) == -1)
  1581. X        return -1;
  1582. X
  1583. X    return 0;
  1584. X}
  1585. X
  1586. Xint
  1587. Xgeneric_setuid(syscallno)
  1588. Xint    syscallno;
  1589. X{
  1590. X    Rstart;
  1591. X    return_value0 = syscall(syscallno, (int)arg[0]);
  1592. X    return_errno = errno;
  1593. X    Rstop;
  1594. X
  1595. X    return 0;
  1596. X}
  1597. X
  1598. Xint
  1599. Xgeneric_shutdown(syscallno)
  1600. Xint    syscallno;
  1601. X{
  1602. X    Rstart;
  1603. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), (int)arg[1]);
  1604. X    return_errno = errno;
  1605. X    Rstop;
  1606. X
  1607. X    return 0;
  1608. X}
  1609. X
  1610. Xint
  1611. Xgeneric_socket(syscallno)
  1612. Xint    syscallno;
  1613. X{
  1614. X    Rstart;
  1615. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  1616. X    return_errno = errno;
  1617. X    Rstop;
  1618. X
  1619. X    if (return_value0 != -1)
  1620. X        return_value0 = fd_open(return_value0);
  1621. X
  1622. X    return 0;
  1623. X}
  1624. X
  1625. Xint
  1626. Xgeneric_socketpair(syscallno)
  1627. Xint    syscallno;
  1628. X{
  1629. X    int    *svp;
  1630. X
  1631. X    if (dmget(arg[3], 2 * sizeof(*svp), &svp) == -1)
  1632. X        return -1;
  1633. X
  1634. X    Rstart;
  1635. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2], svp);
  1636. X    return_errno = errno;
  1637. X    Rstop;
  1638. X
  1639. X    if (dmput(arg[3], svp, 2 * sizeof(*svp), return_value0) == -1)
  1640. X        return -1;
  1641. X
  1642. X    return 0;
  1643. X}
  1644. X
  1645. Xint
  1646. Xgeneric_stat(syscallno, statb, statbz)
  1647. Xint    syscallno;
  1648. Xvoid    *statb;
  1649. Xint    statbz;
  1650. X{
  1651. X    char    *cp;
  1652. X    void    *statbp;
  1653. X
  1654. X    if (mgets(arg[0], &cp) == -1)
  1655. X        return -1;
  1656. X
  1657. X    if (mget(arg[1], statb, statbz, &statbp) == -1)
  1658. X        return -1;
  1659. X
  1660. X    Rstart;
  1661. X    return_value0 = syscall(syscallno, cp, statbp);
  1662. X    return_errno = errno;
  1663. X    Rstop;
  1664. X
  1665. X    if (mput(arg[1], statbp, statbz, return_value0) == -1)
  1666. X        return -1;
  1667. X
  1668. X    return 0;
  1669. X}
  1670. X
  1671. Xint
  1672. Xgeneric_stime(syscallno)
  1673. Xint    syscallno;
  1674. X{
  1675. X    long    *tp;
  1676. X
  1677. X    if (dmget(arg[0], sizeof(*tp), &tp) == -1)
  1678. X        return -1;
  1679. X
  1680. X    Rstart;
  1681. X    return_value0 = syscall(syscallno, tp);
  1682. X    return_errno = errno;
  1683. X    Rstop;
  1684. X
  1685. X    if (dmput(arg[0], tp, sizeof(*tp), return_value0) == -1)
  1686. X        return -1;
  1687. X
  1688. X    return 0;
  1689. X}
  1690. X
  1691. Xint
  1692. Xgeneric_symlink(syscallno)
  1693. Xint    syscallno;
  1694. X{
  1695. X    char    *namep;
  1696. X    char    name1[1024];
  1697. X    char    *cp;
  1698. X
  1699. X    if (mgets(arg[0], &namep) == -1)
  1700. X        return -1;
  1701. X
  1702. X    if (namep != (char *)0)
  1703. X    {
  1704. X        (void)strcpy(&name1[0], namep);
  1705. X        namep = &name1[0];
  1706. X    }
  1707. X
  1708. X    if (mgets(arg[1], &cp) == -1)
  1709. X        return -1;
  1710. X
  1711. X    Rstart;
  1712. X    return_value0 = syscall(syscallno, namep, cp);
  1713. X    return_errno = errno;
  1714. X    Rstop;
  1715. X
  1716. X    return 0;
  1717. X}
  1718. X
  1719. Xint
  1720. Xgeneric_sync(syscallno)
  1721. Xint    syscallno;
  1722. X{
  1723. X    Rstart;
  1724. X    return_value0 = syscall(syscallno);
  1725. X    return_errno = errno;
  1726. X    Rstop;
  1727. X
  1728. X    return 0;
  1729. X}
  1730. X
  1731. Xint
  1732. Xgeneric_time(syscallno)
  1733. Xint    syscallno;
  1734. X{
  1735. X    long    *tlocp;
  1736. X
  1737. X    if (dmget(arg[0], sizeof(*tlocp), &tlocp) == -1)
  1738. X        return -1;
  1739. X
  1740. X    Rstart;
  1741. X    return_value0 = syscall(syscallno, tlocp);
  1742. X    return_errno = errno;
  1743. X    Rstop;
  1744. X
  1745. X    if (dmput(arg[0], tlocp, sizeof(*tlocp), return_value0) == -1)
  1746. X        return -1;
  1747. X
  1748. X    return 0;
  1749. X}
  1750. X
  1751. Xint
  1752. Xgeneric_times(syscallno, tz)
  1753. Xint    syscallno;
  1754. Xint    tz;
  1755. X{
  1756. X    void    *tp;
  1757. X
  1758. X    if (dmget(arg[0], tz, &tp) == -1)
  1759. X        return -1;
  1760. X
  1761. X    Rstart;
  1762. X    return_value0 = syscall(syscallno, tp);
  1763. X    return_errno = errno;
  1764. X    Rstop;
  1765. X
  1766. X    if (dmput(arg[0], tp, tz, return_value0) == -1)
  1767. X        return -1;
  1768. X
  1769. X    return 0;
  1770. X}
  1771. X
  1772. Xint
  1773. Xgeneric_truncate(syscallno)
  1774. Xint    syscallno;
  1775. X{
  1776. X    char    *cp;
  1777. X
  1778. X    if (mgets(arg[0], &cp) == -1)
  1779. X        return -1;
  1780. X
  1781. X    Rstart;
  1782. X    return_value0 = syscall(syscallno, cp, (int)arg[1]);
  1783. X    return_errno = errno;
  1784. X    Rstop;
  1785. X
  1786. X    return 0;
  1787. X}
  1788. X
  1789. Xint
  1790. Xgeneric_uadmin(syscallno)
  1791. Xint    syscallno;
  1792. X{
  1793. X    Rstart;
  1794. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1], (int)arg[2]);
  1795. X    return_errno = errno;
  1796. X    Rstop;
  1797. X
  1798. X    return 0;
  1799. X}
  1800. X
  1801. Xint
  1802. Xgeneric_ulimit(syscallno)
  1803. Xint    syscallno;
  1804. X{
  1805. X    Rstart;
  1806. X    return_value0 = syscall(syscallno, (int)arg[0], (int)arg[1]);
  1807. X    return_errno = errno;
  1808. X    Rstop;
  1809. X
  1810. X    return 0;
  1811. X}
  1812. X
  1813. Xint
  1814. Xgeneric_umask(syscallno)
  1815. Xint    syscallno;
  1816. X{
  1817. X    Rstart;
  1818. X    return_value0 = syscall(syscallno, (int)arg[0]);
  1819. X    return_errno = errno;
  1820. X    Rstop;
  1821. X
  1822. X    return 0;
  1823. X}
  1824. X
  1825. Xint
  1826. Xgeneric_unlink(syscallno)
  1827. Xint    syscallno;
  1828. X{
  1829. X    char    *cp;
  1830. X
  1831. X    if (mgets(arg[0], &cp) == -1)
  1832. X        return -1;
  1833. X
  1834. X    Rstart;
  1835. X    return_value0 = syscall(syscallno, cp);
  1836. X    return_errno = errno;
  1837. X    Rstop;
  1838. X
  1839. X    return 0;
  1840. X}
  1841. X
  1842. Xint
  1843. Xgeneric_unmount(syscallno)
  1844. Xint    syscallno;
  1845. X{
  1846. X    char    *cp;
  1847. X
  1848. X    if (mgets(arg[0], &cp) == -1)
  1849. X        return -1;
  1850. X
  1851. X    Rstart;
  1852. X    return_value0 = syscall(syscallno, cp);
  1853. X    return_errno = errno;
  1854. X    Rstop;
  1855. X
  1856. X    return 0;
  1857. X}
  1858. X
  1859. Xint
  1860. Xgeneric_utime(syscallno, t, tz)
  1861. Xint    syscallno;
  1862. Xvoid    *t;
  1863. Xint    tz;
  1864. X{
  1865. X    char    *cp;
  1866. X    void    *tp;
  1867. X
  1868. X    if (mgets(arg[0], &cp) == -1)
  1869. X        return -1;
  1870. X
  1871. X    if (mget(arg[1], t, tz, &tp) == -1)
  1872. X        return -1;
  1873. X
  1874. X    Rstart;
  1875. X    return_value0 = syscall(syscallno, cp, tp);
  1876. X    return_errno = errno;
  1877. X    Rstop;
  1878. X
  1879. X    return 0;
  1880. X}
  1881. X
  1882. Xint
  1883. Xgeneric_utimes(syscallno, tv, tvz)
  1884. Xint    syscallno;
  1885. Xvoid    *tv;
  1886. Xint    tvz;
  1887. X{
  1888. X    char    *cp;
  1889. X    void    *tvp;
  1890. X
  1891. X    if (mgets(arg[0], &cp) == -1)
  1892. X        return -1;
  1893. X
  1894. X    if (mget(arg[1], tv, tvz, &tvp) == -1)
  1895. X        return -1;
  1896. X
  1897. X    Rstart;
  1898. X    return_value0 = syscall(syscallno, cp, tvp);
  1899. X    return_errno = errno;
  1900. X    Rstop;
  1901. X
  1902. X    if (mput(arg[1], tvp, tvz, return_value0) == -1)
  1903. X        return -1;
  1904. X
  1905. X    return 0;
  1906. X}
  1907. X
  1908. Xint
  1909. Xgeneric_vhangup(syscallno)
  1910. Xint    syscallno;
  1911. X{
  1912. X    Rstart;
  1913. X    return_value0 = syscall(syscallno);
  1914. X    return_errno = errno;
  1915. X    Rstop;
  1916. X
  1917. X    return 0;
  1918. X}
  1919. X
  1920. Xint
  1921. Xgeneric_wait3(syscallno, s, sz, r, rz)
  1922. Xint    syscallno;
  1923. Xvoid    *s;
  1924. Xint    sz;
  1925. Xvoid    *r;
  1926. Xint    rz;
  1927. X{
  1928. X    void    *sp;
  1929. X    void    *rp;
  1930. X
  1931. X    if (mget(arg[0], s, sz, &sp) == -1)
  1932. X        return -1;
  1933. X
  1934. X    if (mget(arg[2], r, rz, &rp) == -1)
  1935. X        return -1;
  1936. X
  1937. X    Rstart;
  1938. X    return_value0 = syscall(syscallno, sp, arg[1], rp);
  1939. X    return_errno = errno;
  1940. X    Rstop;
  1941. X
  1942. X    if (mput(arg[2], rp, rz, return_value0) == -1)
  1943. X        return -1;
  1944. X
  1945. X    if (mput(arg[0], sp, sz, return_value0) == -1)
  1946. X        return -1;
  1947. X
  1948. X    return 0;
  1949. X}
  1950. X
  1951. Xint
  1952. Xgeneric_write(syscallno)
  1953. Xint    syscallno;
  1954. X{
  1955. X    char    *buf;
  1956. X    int    nbyte;
  1957. X
  1958. X    nbyte = arg[2];
  1959. X
  1960. X    if (dmget(arg[1], nbyte, &buf) == -1)
  1961. X        return -1;
  1962. X
  1963. X    Rstart;
  1964. X    return_value0 = syscall(syscallno, fd_lookup((int)arg[0]), buf, nbyte);
  1965. X    return_errno = errno;
  1966. X    Rstop;
  1967. X
  1968. X    return 0;
  1969. X}
  1970. END_OF_FILE
  1971. if test 28291 -ne `wc -c <'generic.c'`; then
  1972.     echo shar: \"'generic.c'\" unpacked with wrong size!
  1973. fi
  1974. # end of 'generic.c'
  1975. fi
  1976. echo shar: End of archive 5 \(of 8\).
  1977. cp /dev/null ark5isdone
  1978. MISSING=""
  1979. for I in 1 2 3 4 5 6 7 8 ; do
  1980.     if test ! -f ark${I}isdone ; then
  1981.     MISSING="${MISSING} ${I}"
  1982.     fi
  1983. done
  1984. if test "${MISSING}" = "" ; then
  1985.     echo You have unpacked all 8 archives.
  1986.     rm -f ark[1-9]isdone
  1987. else
  1988.     echo You still need to unpack the following archives:
  1989.     echo "        " ${MISSING}
  1990. fi
  1991. ##  End of shell archive.
  1992. exit 0
  1993.